home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / dev / gui / BGUI11B.lha / docs / windowclass.doc < prev   
Text File  |  1994-11-21  |  28KB  |  775 lines
  1.  
  2.            $RCSfile: windowclass.doc,v $
  3.         Description: Windowclass documentation.
  4.           Copyright: (C) Copyright 1994 Jaba Development.
  5.                      (C) Copyright 1994 Jan van den Baard.
  6.                      All Rights Reserved.
  7.  
  8.             $Author: jaba $
  9.           $Revision: 1.8 $
  10.               $Date: 1994/11/15 14:27:16 $
  11. ------------------------------------------------------------------------------
  12.  
  13. TABLE OF CONTENTS
  14.  
  15. windowclass/--background--
  16. windowclass/Methods
  17. windowclass/Attributes
  18.  
  19. windowclass/--background--                          windowclass/--background--
  20.  
  21.     NAME
  22.         Class:          windowclass
  23.         Superclass:     ROOTCLASS
  24.         Include File:   <libraries/bgui.h>
  25.  
  26.     FUNCTION
  27.         To  provide  an  easy  to use BGUI interface to intuition windows. The
  28.         window  class  provides just about anything you need to create windows
  29.         with a fully font sensitive and size adjustable GUI.
  30.  
  31. windowclass/Methods                                        windowclass/Methods
  32.  
  33.     NEW METHODS
  34.         WM_OPEN -- This method must be used to open the window.  When a window
  35.                 object is created it does not open right away.
  36.  
  37.                 Returns a pointer to the opened window uppon success  and NULL
  38.                 uppon failure.
  39.  
  40.         WM_CLOSE -- This method must be used to close the window again.  It is
  41.                 safe to call this method even when the window is not open.
  42.  
  43.                 Returns TRUE uppon success and FALSE uppon failure.
  44.  
  45.         WM_SLEEP -- With this method you can put your window to sleep  when it
  46.                 is  open.   This  is  done  by  setting  up a  small invisible
  47.                 requester and a busy pointer.
  48.  
  49.                 Returns TRUE uppon success and FALSE uppon failure.
  50.  
  51.         WM_WAKEUP -- This methos must be  used to  wake  up the  window again.
  52.                 Please note that you must wake up the window as many  times as
  53.                 you have put it to sleep before you can actually use it again.
  54.                 Both the WM_SLEEP and WM_WAKEUP methods can be nested.
  55.  
  56.                 Returns TRUE uppon success and FALSE uppon failure.
  57.  
  58.         WM_HANDLEIDCMP -- This method must be  used  to call  the  windowclass
  59.                 event handler. The event handler will  act  uppon the messages
  60.                 present at the window it's message  port  and  return  you one
  61.                 of the following return codes:
  62.  
  63.                 WMHI_CLOSEWINDOW -- The window it's close gadget was selected.
  64.                 WMHI_NOMORE -- No more messages waiting.
  65.                 WMHI_INACTIVE -- The window was de-activated.
  66.                 WMHI_ACTIVE -- The window was activated.
  67.                 WMHI_IGNORE -- Ignore this result.
  68.  
  69.                 Any return code which differs from the ones  above is  the  ID
  70.                 of a selected object (gadget or menu).
  71.  
  72.                 Please look at the demo programs for more information.
  73.  
  74.         WM_GADGETKEY -- With this method you  can  assign a  key to  trigger a
  75.                 gadget object in the window.  This method  uses the  following
  76.                 custom message structure:
  77.  
  78.                 struct wmGadgetKey {
  79.                         ULONG             MethodID;  /* WM_GADGETKEY */
  80.                         struct Requester *wmgk_Requester;
  81.                         Object           *wmgk_Object;
  82.                         STRPTR            wmgk_Key;
  83.                 };
  84.  
  85.                 wmgk_Requester -- This version of the library does not support
  86.                         BGUI gadget objects in requesters  so this  field must
  87.                         be set to NULL.
  88.  
  89.                 wmgk_Object -- This must be  a  pointer to  the  object  which
  90.                         must be controlled by the key.
  91.  
  92.                 wmgk_Key -- This must point to a  string  in   which  a single
  93.                         character is located. The character is  the  key which
  94.                         controls the object when it is pressed.
  95.  
  96.                 Returns TRUE uppon success and FALSE uppon failure.
  97.  
  98.         WM_KEYACTIVE, WM_KEYINPUT, WM_KEY_INACTIVE -- These three  methods are
  99.                 sent to the gadget object during a key-session.  Please  refer
  100.                 to the "methods.doc" file for more information.
  101.  
  102.         WM_DISABLEMENU, WM_CHECKITEM -- These  two  methods  must  be  used to
  103.                 disable or enable a menu or a menu item or to set or clear the
  104.                 check mark of a CHECKIT item.   These  methods  both  use  the
  105.                 following custom message structure:
  106.  
  107.                 struct wmMenuAction {
  108.                         ULONG             MethodID; /* Any of the above. */
  109.                         ULONG             wmma_MenuID;
  110.                         ULONG             wmma_Set;
  111.                 };
  112.  
  113.                 wmma_MenuID -- This must be the ID of the  menu/item  on which
  114.                         the operation is done. The ID is  the value  which you
  115.                         set in the nm_UserData field of the NewMenu structure.
  116.  
  117.                 wmma_Set -- This is a boolean which  disables/checks  the menu
  118.                         when set to  TRUE  or  enables/unchecks the  menu when
  119.                         set to FALSE.
  120.  
  121.                 Returns TRUE uppon success and FALSE uppon failure.
  122.  
  123.         WM_MENUDISABLED, WM_ITEMCHECKED -- These two methods  must  be used to
  124.                 query about the disabled/checked state of a menu. Both methods
  125.                 use the following custom message structure:
  126.  
  127.                 struct wmMenuQuery {
  128.                         ULONG             MethodID; /* Any of the above. */
  129.                         ULONG             wmmq_MenuID;
  130.                 };
  131.  
  132.                 wmmq_MenuID -- This must be the ID of the  menu/item  on which
  133.                         the operation is done. The ID is  the value  which you
  134.                         set in the nm_UserData field of the NewMenu structure.
  135.  
  136.                 Returns TRUE if the menu is disabled/checked and FALSE if not.
  137.                 A return code of ~0 means that the menu is unknown or no menus
  138.                 are available.
  139.  
  140.         WM_TABCYCLE_ORDER -- With this method you can  determine the  order of
  141.                 tab-cycling.  This method uses  the  following  custom message
  142.                 structure:
  143.  
  144.                 struct wmTabCycleOrder {
  145.                         ULONG             MethodID; /* WM_TABCYCLE_ORDER */
  146.                         Object           *wtco_Object1;
  147.                         /* Object        *wtco_Object2; */
  148.                         /* ... */
  149.                         /* NULL */
  150.                 };
  151.  
  152.                 wtco_Object1 -- The first of a the objects which  will be  set
  153.                         in the tab-cycle chain.   Please  note  that you  must
  154.                         terminate the method with a NULL pointer.
  155.  
  156.                 Returns TRUE uppon success and FALSE uppon failure.
  157.  
  158.         WM_GETAPPMSG -- This method must be used  to get the AppWindow message
  159.                 when one is available.  Please note that _you_ are  resposible
  160.                 for replying the message.
  161.  
  162.                 Returns a pointer to the AppMessage or NULL when  there was no
  163.                 message.
  164.  
  165.         WM_ADDUPDATE -- This method must be used  to  perform  simple map-list
  166.                 notification with  externalclass  objects.  The  externalclass
  167.                 objects are not able to perform  notification  like  the other
  168.                 gadget classes. This method uses the  following custom message
  169.                 structure:
  170.  
  171.                 struct wmAddUpdate {
  172.                         ULONG             MethodID; /* WM_ADDUPDATE */
  173.                         ULONG             wmau_SourceID;
  174.                         Object           *wmau_Target;
  175.                         struct TagItem   *wmau_MapList;
  176.                 };
  177.  
  178.                 wmau_SourceID -- This must be the ID of the object that send's
  179.                         the notification message.
  180.  
  181.                 wmau_Target -- This must be a  pointer  to  the  object  which
  182.                         must be updated by the notiication.
  183.  
  184.                 wmau_MapList -- This can pointe to  an  array  of  tags  which
  185.                         contain the attributes to map.  This may also  be NULL
  186.                         in which case no mapping is done.
  187.  
  188.                 Return TRUE uppon success and FALSE uppon failure.
  189.  
  190.         WM_REPORT_ID ** V38 ** -- This method  will  allow  an  IDCMP-hook  or
  191.                 Verify-hook to report ID's  to  the  application program.   It
  192.                 will  stack  the  ID(s)  to  report  and  pass  them  to   the
  193.                 application the next time the WM_HANDLEIDCMP method is called.
  194.                 This  method  uses the following custom message structure:
  195.  
  196.                 struct wmReportID {
  197.                         ULONG           MethodID;       /* WM_REPORT_ID     */
  198.                         ULONG           wmri_ID;
  199.                         ULONG           wmri_Flags;
  200.                 };
  201.  
  202.                 wmri_ID -- This is the ID that is put on the stack.  Next time
  203.                         the application  call's  WM_HANDLEIDCMP on  the object
  204.                         the ID's on the stack are returned.
  205.  
  206.                 wmri_Flags -- This may contain any of the following flags:
  207.  
  208.                         WMRIF_DOUBLE_CLICK -- When this flag is set  the ID to
  209.                                 report   is  put  on  the  stack  twice  which
  210.                                 effectivly simulates a double-click.
  211.  
  212.                 Returns TRUE uppon success and FALSE uppon failure.
  213.  
  214.     CHANGED METHODS
  215.         OM_DISPOSE -- When  this  method is called all objects attached to the
  216.                 window with the WINDOW_MasterGroup attribute are also disposed
  217.                 of.
  218.  
  219. windowclass/Attributes                                  windowclass/Attributes
  220.  
  221.     NAME
  222.         WINDOW_Position -- ( ULONG )
  223.  
  224.     FUNCTION
  225.         To determine the position at which the window is opened. These are the
  226.         possibilities:
  227.  
  228.         POS_CENTERSCREEN -- The window is centered in the visible part  of the
  229.                 screen it is opened on.
  230.         POS_CENTERMOUSE -- The window is centered under  the mouse.  Depending
  231.                 on the location of the mouse this might differ a little.
  232.         POS_TOPLEFT -- The window is opened  at  the  top-left  corner  in the
  233.                 visible part of the screen it is opened on.
  234.  
  235.         Default is POS_CENTERSCREEN. Applicability is (I).
  236.  
  237.     SEE ALSO
  238.         WINDOW_PosRelBox
  239.  
  240.     NAME
  241.         WINDOW_ScaleWidth, WINDOW_ScaleHeight -- ( ULONG )
  242.  
  243.     FUNCTION
  244.         To open a window larger than it's minimum size. The data you pass with
  245.         these tags must be the percentage (0%..100%) of the  visible  size  of
  246.         the screen minus the minimum size of the window.  For example you have
  247.         a  window which is 100 pixels wide at it's minimum size  on  a  screen
  248.         which   is  1000   pixels   wide   (visible)   and   you  pass  25  as
  249.         WINDOW_ScaleWidth  the window is opened 325 pixels wide.
  250.  
  251.         (( 1000 - 100 ) / 100 ) * 25 = 225
  252.  
  253.         225 + 100 = 325
  254.  
  255.         Defaults are 0. Applicability is (I).
  256.  
  257.     NAME
  258.         WINDOW_LockWidth, WINDOW_LockHeight -- ( BOOL )
  259.  
  260.     FUNCTION
  261.         To disable sizing the width or height of a window.
  262.  
  263.         Defaults are FALSE. Applicability is (I).
  264.  
  265.     NAME
  266.         WINDOW_PosRelBox -- ( struct IBox * )
  267.  
  268.     FUNCTION
  269.         To open the window centered in the described box.  The  data  you pass
  270.         here must be a pointer to a struct IBox in which the location and size
  271.         of the box is described. This will allow you to easely center a window
  272.         uppon another window like this:
  273.  
  274.         struct Window           *parent;
  275.         struct IBox              position;
  276.         Object                  *window_object;
  277.  
  278.         /*
  279.         **      Copy the parent location/size.
  280.         **/
  281.         position = *(( struct IBox * )&parent->LeftEdge );
  282.  
  283.         window_object = WindowObject,
  284.                 WINDOW_PosRelBox,               &position,
  285.                 ....
  286.         EndObject;
  287.  
  288.     SEE ALSO
  289.         WINDOW_Position
  290.  
  291.     NAME
  292.         WINDOW_DragBar,         WINDOW_SizeGadget,         WINDOW_CloseGadget,
  293.         WINDOW_DepthGadget -- ( BOOL )
  294.  
  295.     FUNCTION
  296.         To switch on or off the corresponding system gadgets.
  297.  
  298.         Default for all are TRUE. Applicability is (I).
  299.  
  300.     NAME
  301.         WINDOW_SizeBottom, WINDOW_SizeBright -- ( BOOL )
  302.  
  303.     FUNCTION
  304.         To determine the place of the sizing gadget.
  305.  
  306.         Default is TRUE for bottom and FALSE for right. Applicability is (I).
  307.  
  308.     NAME
  309.         WINDOW_Activate -- ( BOOL )
  310.  
  311.     FUNCTION
  312.         To activate the window right after it is opened.
  313.  
  314.         Default is TRUE. Applicability is (I).
  315.  
  316.     NAME
  317.         WINDOW_RMBTrap -- ( BOOL )
  318.  
  319.     FUNCTION
  320.         To set/clear the WFLG_RMBTRAP  flag.  When set this disables the right
  321.         from  activating  the  menu-strip.   It will also make the right mouse
  322.         button visible in intuition events.
  323.  
  324.         Default is FALSE. Applicability is (I).
  325.  
  326.     NAME
  327.         WINDOW_SmartRefresh -- ( BOOL )
  328.  
  329.     FUNCTION
  330.         To set/clear the WFLG_SMART_REFRESH flag.
  331.  
  332.         Default is FALSE. Applicability is (I).
  333.  
  334.     NAME
  335.         WINDOW_ReportMouse -- ( BOOL )
  336.  
  337.     FUNCTION
  338.         To set/clear the WFLG_REPORTMOUSE flags.
  339.  
  340.         Default is FALSE. Applicability is (I).
  341.  
  342.     NAME
  343.         WINDOW_IDCMP -- ( ULONG )
  344.  
  345.     FUNCTION
  346.         To set extra IDCMP flags which are not automatically set by the window
  347.         class  itself.  This  might  be  necessary  for  the  WINDOW_IDCMPHook
  348.         described below.   The following  flags are  automatically set  by the
  349.         window class:
  350.  
  351.         IDCMP_RAWKEY                    - Key control of gadgets.
  352.         IDCMP_GADGETUP                  - The obvious.
  353.         IDCMP_CHANGEWINDOW              - To track window changes.
  354.         IDCMP_INACTIVEWINDOW            - To report window inactivation.
  355.         IDCMP_ACTIVEWINDOW              - To report window activation.
  356.         IDCMP_IDCMPUPDATE               - For WM_ADDUPDATE notification,
  357.                                           tab-cycling and continues slider and
  358.                                           scroller reporting.
  359.         IDCMP_CLOSEWINDOW               - To report clicking the close gadget.
  360.         IDCMP_MENUPICK                  - To report menu-selections.
  361.  
  362.         Please  note  that  IDCMP_VANILLAKEY  must  _not_  be set. The current
  363.         keyboard handling does not allow this.
  364.  
  365.         Default is 0. Applicability is (I).
  366.  
  367.     SEE ALSO
  368.         WINDOW_IDCMPHook
  369.  
  370.     NAME
  371.         WINDOW_SharedPort -- ( struct MsgPort * )
  372.  
  373.     FUNCTION
  374.         To use a shared message port for the window.  If you pass a pointer to
  375.         a valid message port here the window will use this  port for receiving
  376.         events.
  377.  
  378.         Default is NULL. Applicability is (I).
  379.  
  380.     NAME
  381.         WINDOW_Title, WINDOW_ScreenTitle -- ( STRPTR )
  382.  
  383.     FUNCTION
  384.         To set the window title and the title of  the screen  while the window
  385.         is active.
  386.  
  387.         Defaults are NULL. Applicability is (ISU).
  388.  
  389.     NAME
  390.         WINDOW_MenuStrip -- ( struct NewMenu * ) ( struct Menu * )
  391.  
  392.     FUNCTION
  393.         This attribute has two data types to be considered.  Uppon creation of
  394.         the  window  object  the  data  expected  is  a pointer to an array of
  395.         NewMenu  structures  as  defined  in  <libraries/gadtools.h>. When you
  396.         obtain  this  attribute  with  OM_GET  you  will  get a pointer to the
  397.         created menus.
  398.  
  399.         To  make  the  menus  visible  to  your  program  you  must give every
  400.         selectable  menu an ID. The ID must be placed in the nm_UserData field
  401.         of the corresponding NewMenu structure.
  402.  
  403.         Example:
  404.  
  405.         #define ID_ABOUT        1
  406.         #define ID_QUIT         2
  407.  
  408.         struct NewMenu Menus {
  409.                 { NM_TITLE,  "Project",   NULL, 0, 0, NULL },
  410.                 { NM_ITEM,   "About...",  "?",  0, 0, (APTR)ID_ABOUT },
  411.                 { NM_ITEM,   NM_BARLABEL, NULL, 0, 0, NULL },
  412.                 { NM_ITEM,   "Quit",      "Q",  0, 0, (APTR)ID_QUIT },
  413.                 { NM_END,    NULL,        NULL, 0, 0, NULL }
  414.         }
  415.  
  416.         The  WM_HANDLEIDCMP  method  will  return ID_ABOUT when the "About..."
  417.         item is selected and ID_QUIT when the "Quit" item is selected.
  418.  
  419.         Default is NULL. Applicability is (IG).
  420.  
  421.     NAME
  422.         WINDOW_MasterGroup -- ( Object * )
  423.  
  424.     FUNCTION
  425.         To  set  the master group containing all objects for the window.  This
  426.         attribute   data   _must_  point  to a valid groupclass object or else
  427.         the  window  object  creation    will    fail.   It's   currently  not
  428.         possible   to   create   a  windowclass  object without a group object
  429.         attached  to it. The data expected here is a pointer to the groupclass
  430.         object  containing  all other gadget objects.
  431.  
  432.         Example:
  433.  
  434.         Object                  *WO_Window;
  435.  
  436.         WO_Window = WindowObject,
  437.                 WINDOW_Title,           "Whatever",
  438.                 ...
  439.                 WINDOW_MasterGroup,
  440.                         HGroupObject, HOffset( 4 ), VOffset( 4 ),
  441.                                 StartMember,
  442.                                         Button( "Quit", 0 ),
  443.                                 EndMember,
  444.                         EndObject,
  445.         EndObject;
  446.  
  447.         Default is NULL. Applicability is (I).
  448.  
  449.     NAME
  450.         WINDOW_Screen -- ( struct Screen * )
  451.  
  452.     FUNCTION
  453.         To set the custom screen on which the window should open.  If you want
  454.         your  window  to  open on a custom screen you can pass a pointer to it
  455.         here.  Please  note  that you  can use OM_SET to change this attribute
  456.         only when the window is not open.
  457.  
  458.         Default is NULL (default public screen). Applicability is (IS).
  459.  
  460.     SEE ALSO
  461.         WINDOW_PubScreenName
  462.  
  463.     NAME
  464.         WINDOW_PubScreenName -- ( STRPTR )
  465.  
  466.     FUNCTION
  467.         To set the name of the public screen on which the window should  open.
  468.         Please note that you can use  OM_SET  to change  this  attribute  only
  469.         when the window is not open.
  470.  
  471.         Default is NULL (default public screen). Applicability is (IS).
  472.  
  473.     SEE ALSO
  474.         WINDOW_Screen
  475.  
  476.     NAME
  477.         WINDOW_UserPort -- ( struct MsgPort * )
  478.  
  479.     FUNCTION
  480.         To obtain a pointer to the message port of the window.
  481.  
  482.         Applicability is (G).
  483.  
  484.     NAME
  485.         WINDOW_SigMask -- ( ULONG )
  486.  
  487.     FUNCTION
  488.         To  obtain  the  window signal mask.
  489.  
  490.         Example:
  491.  
  492.         Object         *WO_Win;
  493.         ULONG           mask;
  494.  
  495.         GetAttr( WINDOW_SigMask, WO_Win, &mask );
  496.  
  497.         do {
  498.                 Wait( mask );
  499.                 ...
  500.         } while ( ... );
  501.  
  502.         Applicability is (G).
  503.  
  504.     SEE ALSO
  505.         WINDOW_AppMask
  506.  
  507.     NAME
  508.         WINDOW_IDCMPHook, WINDOW_VerifyHook -- ( struct Hook * )
  509.  
  510.     FUNCTION
  511.         To  tie  yourself  into  the IDCMP handling of the window.  With these
  512.         attributes  you  can  set a hook which is called uppon  events set  by
  513.         the  WINDOW_IDCMPHookBits and/or WINDOW_VerifyHookBits attributes. The
  514.         hooks are called as follows:
  515.  
  516.         void hookRoutine( hook, object, imsg )
  517.                           A0    A2      A1
  518.  
  519.         struct Hook             *hook;
  520.         Object                  *object;
  521.         struct IntuiMessage     *imsg;
  522.  
  523.         The  pointer  to  the  IntuiMessage  structure  is read-only. Also the
  524.         message  is  passed to you before it is reply'd so you should not take
  525.         to long before returning.
  526.  
  527.         The  IDCMPHook  is  called  after  the window object has done it's own
  528.         processing on the message. The VerifyHook is called directly while the
  529.         window object does not need to process any verification messages.
  530.  
  531.         Default is NULL. Applicability is (I).
  532.  
  533.     SEE ALSO
  534.         WINDOW_IDCMP, WINDOW_IDCMPHookBits, WINDOW_VerifyHookBits
  535.  
  536.     NAME
  537.         WINDOW_IDCMPHookBits, WINDOW_VerifyHookBits -- ( ULONG )
  538.  
  539.     FUNCTION
  540.         To  set  the  bits  that  will cause the IDCMPHook or VerifyHook to be
  541.         called.  The bits you pass here are the standard system IDCMP_xxx flag
  542.         bits  found in <intuition/intuition.h>. Please note that some of these
  543.         bits  require  you  to set them first using the WINDOW_IDCMP attribute
  544.         described above.
  545.  
  546.         Example:
  547.  
  548.         struct Hook             *idcmp_hook;
  549.         Object                  *wd_obj;
  550.  
  551.         wd_obj = WindowObject,
  552.                 WINDOW_IDCMP,           IDCMP_INTUITICKS,
  553.                 WINDOW_IDCMPHook,       idcmp_hook,
  554.                 WINDOW_IDCMPHookBits,   IDCMP_INTUITICKS,
  555.                 ...
  556.         EndObject;
  557.  
  558.         This   will   cause   the   WINDOW_IDCMPHook  to  be  called  at  each
  559.         IDCMP_INTUITICKS event.
  560.  
  561.         Please note that the window class does not filter  out  any non-verify
  562.         bits  from  the WINDOW_VerifyHookBits you pass. This means that if you
  563.         set  IDCMP_GADGETUP  in  the  verification bits you will block out the
  564.         window  object  event  handler  from  receiving  gadget  messages. The
  565.         verification bits set should be restricted to the following bits:
  566.  
  567.         IDCMP_REQVERIFY
  568.         IDCMP_MENUVERIFY
  569.  
  570.         Defaults are 0. Applicability is (I).
  571.  
  572.     SEE ALSO
  573.         WINDOW_IDCMP, WINDOW_IDCMPHook, WINDOW_VerifyHook
  574.  
  575.     NAME
  576.         WINDOW_Font -- ( struct TextAttr * )
  577.  
  578.     FUNCTION
  579.         To  set the font to be used by the gadget objects. By default the font
  580.         of  the  screen the window is opened on is used. With this tag you can
  581.         select your own font.  Note that the font is opened with OpenFont() so
  582.         please make sure it is present in memory.
  583.  
  584.         Default is NULL. Applicability is (I).
  585.  
  586.     SEE ALSO
  587.         WINDOW_FallBackFont
  588.  
  589.     NAME
  590.         WINDOW_FallBackFont -- ( struct TextAttr * )
  591.  
  592.     FUNCTION
  593.         To  set the font to try whenever a window fails to open because it has
  594.         grown  to big for the screen. By default the fallback font is topaz 8.
  595.         If  you  pass a TextAttr here the window object will first try to fall
  596.         back  to  the supplied font and, if that also fails, it will try topaz
  597.         8. When topaz 8 fails the window will not open.  Note that the font is
  598.         opened with OpenFont() so please make sure it is present in memory.
  599.  
  600.         Default is NULL. Applicability is (I).
  601.  
  602.     SEE ALSO
  603.         WINDOW_Font
  604.  
  605.     NAME
  606.         WINDOW_HelpFile -- ( STRPTR )
  607.  
  608.     FUNCTION
  609.         Set the name of the file to be displayed when a  help-request  for the
  610.         object arives. Please note that the full path-name must be given.
  611.  
  612.         Default is NULL. Applicability is (IS).
  613.  
  614.     SEE ALSO
  615.         WINDOW_HelpNode, WINDOW_HelpLine
  616.  
  617.     NAME
  618.         WINDOW_HelpNode -- ( STRPTR )
  619.  
  620.     FUNCTION
  621.         Set the name of the node which is diplayed in the help window.
  622.  
  623.         Default is NULL. Applicability is (IS).
  624.  
  625.     SEE ALSO
  626.         WINDOW_HelpFile, WINDOW_HelpLine
  627.  
  628.     NAME
  629.         WINDOW_HelpLine - ( ULONG )
  630.  
  631.     FUNCTION
  632.         Set the line number  from  which the  file is  displayed.  This may be
  633.         useful if the help-file is not an AmigaGuide file.
  634.  
  635.         Default is 0. Applicability is (IS).
  636.  
  637.     SEE ALSO
  638.         WINDOW_HelpFile, WINDOW_HelpNode
  639.  
  640.     NAME
  641.         WINDOW_AppWindow -- ( BOOL )
  642.  
  643.     FUNCTION
  644.         To make the window an AppWindow.
  645.  
  646.         Default is FALSE. Applicability is (I).
  647.  
  648.     SEE ALSO
  649.         WINDOW_AppMask
  650.  
  651.     NAME
  652.         WINDOW_AppMask -- ( ULONG )
  653.  
  654.     FUNCTION
  655.         To  obtain  the app-window signal mask.
  656.  
  657.         Example:
  658.  
  659.         Object         *WO_Win;
  660.         ULONG           mask;
  661.  
  662.         GetAttr( WINDOW_AppMask, WO_Win, &mask );
  663.  
  664.         do {
  665.                 Wait( mask );
  666.                 ...
  667.         } while ( ... );
  668.  
  669.         Applicability is (G).
  670.  
  671.     SEE ALSO
  672.         WINDOW_SigMask
  673.  
  674.     NAME
  675.         WINDOW_UniqueID -- ( ULONG )
  676.  
  677.     FUNCTION
  678.         To provide the window with an ID. The ID must be a 32bit integer which
  679.         is  used  to  store  information on the window it's position and size.
  680.         This  allows  you to close and dispose of the window object, re-create
  681.         it  with the same ID, and the position and size of the window the last
  682.         time it was open is still the same.
  683.  
  684.         This tag  tracks  the  complete window bounds but if you re-create and
  685.         open your window with the WINDOW_PosRelBox tag specified only the size
  686.         of the  window is re-stored. The size will remain the same as the last
  687.         time the  window  was  open  but  the position will be adjusted to the
  688.         bounds specified with the WINDOW_PosRelBox tag.
  689.  
  690.         The ID must be non-NULL.
  691.  
  692.         Default is 0 (no storage is done). Applicability is (I).
  693.  
  694.     SEE ALSO
  695.         WINDOW_PosRelBox
  696.  
  697.     NAME
  698.         WINDOW_Window -- ( struct Window * )
  699.  
  700.     FUNCTION
  701.         To get a pointer to the window structure.  The pointer you get will be
  702.         NULL if the window is not opened.
  703.  
  704.         Applicability is (G).
  705.  
  706.     NAME
  707.         WINDOW_Bounds -- ( struct IBox * )
  708.  
  709.     FUNCTION
  710.         To  enable  you  to pick the position and the size of the window. This
  711.         attribute expects a pointer to a struct IBox in which the position and
  712.         size are stored. The windowclass will check the values and adjust them
  713.         if necessary. I.E. You cannot specify a size smaller than  the minimum
  714.         possible size.  Query this attribute with  OM_GET to find  out exactly
  715.         where the window is located and what it's size is.
  716.  
  717.         Querying this attribute with OM_GET is only  possible when  the window
  718.         is open. To get this attribute with OM_GET you specify  a pointer to a
  719.         struct IBox in the method.   The  class  will  write the bounds in the
  720.         struct IBox.
  721.  
  722.         Please  note  that  this   attribute   overides  the  WINDOW_Position,
  723.         WINDOW_ScaleWidth, WINDOW_ScaleHeight and WINDOW_PosRelBox attributes.
  724.  
  725.         Default is NULL. Applicability is (ISG).
  726.  
  727.     SEE ALSO
  728.         WINDOW_Position, WINDOW_ScaleWidth, WINDOW_ScaleHeight,
  729.         WINDOW_PosRelBox
  730.  
  731.     NAME
  732.         WINDOW_HelpText -- ( STRPTR)
  733.  
  734.     FUNCTION
  735.         To setup  a  text  which  will be displayed if the help-key is pressed
  736.         while the  mouse  pointer  is located above the window. This attribute
  737.         should be  used  to  attach small on-line help to the window. The text
  738.         you specify will be shown in a small BGUI_RequestA() type of requester
  739.         so you  must  make  sure  that  everything  fit's  nicely on a 600x200
  740.         screen.
  741.  
  742.         The specified text may contain any of the infoclass command sequences.
  743.  
  744.         This   attribute  overides  the  WINDOW_HelpFile,  WINDOW_HelpNode and
  745.         WINDOW_HelpLine attributes.
  746.  
  747.         Default is NULL. Applicability (IS).
  748.  
  749.     SEE ALSO
  750.         WINDOW_HelpFile, WINDOW_HelpNode, WINDOW_HelpLine,
  751.         infoclass/INFO_TextFormat, bgui.library/BGUI_RequestA()
  752.  
  753.     NAME
  754.         WINDOW_NoBufferRP -- ( BOOL )
  755.  
  756.     FUNCTION
  757.         When this attribute is  set to  TRUE the  windowclass  will  tell  the
  758.         layout engine not to  setup a  buffer  RastPort  which  means that all
  759.         rendering occures  on-screen.   This may be handy when you use objects
  760.         which  take  some  time  to  render  like the colorwheel.gadget on 256
  761.         colour screens.
  762.  
  763.         Default is FALSE. Applicability is (I).
  764.  
  765.     NAME
  766.         WINDOW_AutoAspect -- ( BOOL )
  767.  
  768.     FUNCTION
  769.         When this attribute is set the  windowclass  will  automatically  make
  770.         aspect ratio dependant decisions  about the  resulting GUI.  Currently
  771.         the only thing it does is selecting the frame  thickness.  Other stuff
  772.         like spacing and offsets might be added in the future.
  773.  
  774.         Default is FALSE. Applicability is (I).
  775.